import axios from 'axios';

// 创建axios实例，设置基础URL
const api = axios.create({
  baseURL: import.meta.env.VITE_API_BASE_URL,
  timeout: 10000000, // 考虑到LLM生成可能需要较长时间，设置较长的超时时间
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
  }
});
const api_json = axios.create({
  baseURL: import.meta.env.VITE_API_BASE_URL,
  timeout: 1000000, // 考虑到LLM生成可能需要较长时间，设置较长的超时时间
  headers: {
    'Content-Type': 'application/json',
  }
});

/**
 * 调用后端接口生成项目描述
 * @param {string} prompt - 用户输入的项目需求描述
 * @returns {Promise<string>} - 返回LLM生成的项目详细描述
 */
export const generateProjectDescription = async (prompt) => {
  try {
    // 实际项目中，这里应该调用后端的 /generate 接口
    // 目前先使用 mock 数据进行演示
    if (import.meta.env.VITE_DEV == "true" && !(import.meta.env.VITE_USE_REAL_API == "true")) {
      // 开发环境下使用 mock 数据
      await new Promise(resolve => setTimeout(resolve, 200)); // 模拟网络延迟
      return mockResponse(prompt);
    } else {
      // 实际API调用
      const response = await api.post('/intention/extract', { intention: prompt });
      return response.data;
    }
  } catch (error) {
    console.error('调用生成API失败:', error);
    throw new Error('无法生成项目描述，请稍后重试');
  }
};
export const getProjectDescription = async (intentionID) => {
  try {
    let response = await api.get('/intention/query', {
      params: {
        intentionID: intentionID
      }
    });
    response = response.data
    response.data.intention.intentionID = response.data.intentionID
    response = response.data.intention;
    return response;

  } catch (error) {
    console.error('调用生成API失败:', error);
    throw new Error('无法生成项目描述，请稍后重试');
  }
}
export const postProjectDescription = async (projectDescription) => {
  try {
    // 目前先使用 mock 数据进行演示
    if (import.meta.env.VITE_DEV == "true" && !(import.meta.env.VITE_USE_REAL_API == "true")) {
      // 开发环境下使用 mock 数据
      await new Promise(resolve => setTimeout(resolve, 200)); // 模拟网络延迟
      return true;
    } else {
      console.log(projectDescription)
      // 实际API调用
      let data = {}
      data.intention = {
        intention: projectDescription.intention,
        func: projectDescription.func,
        language: projectDescription.language,
      }
      data.intentionID = projectDescription.intentionID
      console.log("修改后需求:", data)
      const response = await api_json.post('/intention/change', data);
      return response.data.status == '200' || response.data.status == 'success';
    }
  } catch (error) {
    console.error('调用生成API失败:', error);
    throw new Error('无法生成项目描述，请稍后重试');
  }
}
/**
 * 调用项目意图分析接口
 * @param {string} intention - 用户输入的项目需求
 * @returns {Promise<Object>} - 返回解析后的项目意图
 */
export const parseIntention = async (intention) => {
  try {
    const response = await api.get('/api/parse-intention', {
      params: { intention }
    });

    return response.data.intention;
  } catch (error) {
    console.error('调用意图分析API失败:', error);
    throw new Error('无法分析项目意图，请稍后重试');
  }
};

/**
 * 提交修改后的需求描述，获取工作流结构
 * @param {string} requirement - 修改后的需求描述
 * @returns {Promise<Object>} - 返回工作流结构
 */
export const generateWorkflow = async (requirement) => {
  try {
    if (import.meta.env.VITE_DEV == "true" && !(import.meta.env.VITE_USE_REAL_API == "true")) {

      await new Promise(resolve => setTimeout(resolve, 200)); // 模拟网络延迟
      return mockWorkflow(requirement);
    } else {
      // 实际API调用
      console.log(requirement)
      const response = await api_json.post('/workflow/generate', { "intentionID": requirement.intentionID });
      return response.data;
    }
  } catch (error) {
    console.error('调用生成工作流API失败:', error);
    throw new Error('无法生成工作流，请稍后重试');
  }
};
export const postWorkflow = async (workflow) => {
  try {
    if (import.meta.env.VITE_DEV == "true" && !(import.meta.env.VITE_USE_REAL_API == "true")) {

      await new Promise(resolve => setTimeout(resolve, 200)); // 模拟网络延迟
      return true;
    } else {
      // 实际API调用
      const response = await api_json.post('/workflow/change', workflow);
      return response.data.status == '200' || response.data.status == 'success';
    }
  } catch (error) {
    console.error('调用更新工作流API失败:', error);
    throw new Error('无法更新工作流，请稍后重试');
  }
}

export const getWorkflow = async (intentionID) => {
  try {
    const workflow = await api.get('/workflow/queryByIntention', {
      params: {
        "intentionID": intentionID
      }
    });
    let workflowData = typeof workflow === 'string'
      ? JSON.parse(workflow)
      : workflow;
    return workflowData.data;

  } catch (error) {
    console.error('调用获取历史工作流:', error);
    throw new Error('无法获取历史工作流，请稍后重试');
  }
};

/**
 * 根据工作流生成代码
 * @param {Object} workflow - 工作流结构
 * @returns {Promise<string>} - 返回生成的代码
 */
export const generateCode = async (workflow) => {
  try {
    if (import.meta.env.VITE_DEV == "true" && !(import.meta.env.VITE_USE_REAL_API == "true")) {
      // 开发环境下使用 mock 数据
      await new Promise(resolve => setTimeout(resolve, 200)); // 模拟网络延迟
      return mockCode(workflow);
    } else {
      // 实际API调用
      const response = await api_json.post('/code/generate', { "workflowID": workflow.workflowID });
      console.log(response.data)
      return response.data;
    }
  } catch (error) {
    console.error('调用生成代码API失败:', error);
    throw new Error('无法生成代码，请稍后重试');
  }
};
export const getSignleFile = async (fileNo, path) => {
  try {
    if (import.meta.env.VITE_DEV == "true" && !(import.meta.env.VITE_USE_REAL_API == "true")) {
      // 开发环境下使用 mock 数据
      await new Promise(resolve => setTimeout(resolve, 200)); // 模拟网络延迟
      return mockSingleFile();
    } else {

      const response = await api.get('code/file', {
        params: {
          fileNo: fileNo,
          filePath: path,
        }
      });
      return response.data.data.content;
    }
  } catch (error) {
    console.error('调用获取代码API失败:', error);
    throw new Error('无法获取代码，请稍后重试');
  }
}

/**
 * 生成部署指南
 * @param {Object} workflow - 工作流结构
 * @param {string} code - 生成的代码
 * @returns {Promise<string>} - 返回部署指南文本
 */
export const generateDeployGuide = async (codeData) => {
  try {
    if (import.meta.env.VITE_DEV == "true" && !(import.meta.env.VITE_USE_REAL_API == "true")) {
      // 开发环境下使用 mock 数据
      await new Promise(resolve => setTimeout(resolve, 200)); // 模拟网络延迟
      return mockDeployGuide();
    } else {
      console.log(codeData)
      // 实际API调用
      const response = await api.get('code/file', {
        params: {
          fileNo: codeData.fileNo,
          filePath: 'README.md',
        }
      });
      return response.data.data.content;
    }
  } catch (error) {
    console.error('调用生成部署指南API失败:', error);
    throw new Error('无法生成部署指南，请稍后重试');
  }
};

export const getHistoryItems = async () => {
  try {
    if (false && import.meta.env.VITE_DEV == "true" && !(import.meta.env.VITE_USE_REAL_API == "true")) {
      // 开发环境下使用 mock 数据
      await new Promise(resolve => setTimeout(resolve, 200)); // 模拟网络延迟
      return mockHistoryItems();
    } else {
      // 实际API调用
      const response = await api.get('/intention/history');
      return response.data.data.history.history_items;
    }
  } catch (error) {
    console.error('调用获取历史记录API失败:', error);
    throw new Error('无法获取历史记录，请稍后重试');
  }
}
export const donwloadProject = async (codeData) => {

  try {
    if (false && import.meta.env.VITE_DEV == "true" && !(import.meta.env.VITE_USE_REAL_API == "true")) {
      // 开发环境下使用 mock 数据
      await new Promise(resolve => setTimeout(resolve, 200)); // 模拟网络延迟

    } else {
      // console.log(codeData)
      // // 实际API调用
      // const response = await api.get('code/downloadAll', {
      //   params: {
      //     fileNo: codeData.fileNo,
      //   }
      // });
      // 构造下载 URL
      const downloadUrl = new URL('/api/BuildMind/code/downloadAll', window.location.origin);
      downloadUrl.searchParams.append('fileNo', codeData.fileNo);

      // 触发下载
      window.location.href = downloadUrl.toString();
    }
  } catch (error) {
    console.error('调用下载全部代码API失败:', error);
    throw new Error('无法下载全部代码，请稍后重试');
  }
};

export const removeHistoryItem = async (intentionID) => {
  try {
    if (import.meta.env.VITE_DEV == "true" && !(import.meta.env.VITE_USE_REAL_API == "true")) {
      // 开发环境下使用 mock 数据
      await new Promise(resolve => setTimeout(resolve, 200)); // 模拟网络延迟
      return true;
    } else {
      // 实际API调用
      const response = await api_json.post('/intention/delete', { intentionID: intentionID });
      return response.data.status === 'success';
    }
  } catch (error) {
    console.error('调用删除历史记录API失败:', error);
    throw new Error('无法删除历史记录，请稍后重试');
  }
}


/**
 * Mock响应数据，用于开发阶段测试
 * @param {string} prompt - 用户输入
 * @returns {string} - 模拟的LLM响应
 */
function mockResponse(prompt) {
  const mockdata = {
    "data": {
      "intention": {
        "intention": "记账软件",
        "func": [
          {
            "name": "记录收支",
            "description": "用户可以输入收入和支出的金额、类别、日期等信息",
            "input": "金额、类别、日期、备注",
            "output": "保存的记账记录"
          },
          {
            "name": "查看记录",
            "description": "用户可以查看历史记账记录，支持按时间、类别筛选",
            "input": "筛选条件（如时间范围、类别）",
            "output": "符合条件的记账记录列表"
          },
          {
            "name": "统计报表",
            "description": "根据记账记录生成统计报表，如月度收支、类别占比等",
            "input": "统计条件（如时间范围）",
            "output": "统计图表或数据"
          },
          {
            "name": "预算管理",
            "description": "用户可以设置预算，并查看预算执行情况",
            "input": "预算金额、预算类别",
            "output": "预算设置成功提示或预算执行情况"
          },
          {
            "name": "数据导出",
            "description": "用户可以将记账记录导出为Excel或PDF格式",
            "input": "导出格式、时间范围",
            "output": "导出的文件"
          }
        ],
        "language": "web应用（如vue、React）",
        "intentionID": 47
      },
      "intentionID": 47
    },
    "message": "成功提取意图",
    "status": "success"
  }
  return mockdata
}

/**
 * Mock工作流数据，用于开发阶段测试
 * @param {string} requirement - 用户需求
 * @returns {Object} - 模拟的工作流结构
 */
function mockWorkflow(requirement) {
  const mockdata = {
    "data": {
      "workflow": {
        "workflow": "定时喝水提醒应用的工作流，包括设置提醒时间、启动/停止提醒、记录喝水情况和查看历史记录",
        "dataflows": [
          {
            "id": 1,
            "name": "初始化应用",
            "description": "初始化应用状态和UI组件",
            "input": "无",
            "output": "应用初始化完成",
            "jump-list": [
              {
                "condition": "always",
                "id": 2
              }
            ]
          },
          {
            "id": 2,
            "name": "显示主界面",
            "description": "显示主界面，包含设置、启动/停止、记录和查看功能",
            "input": "无",
            "output": "主界面渲染完成",
            "jump-list": [
              {
                "condition": "if user clicks '设置'",
                "id": 3
              },
              {
                "condition": "if user clicks '启动'",
                "id": 4
              },
              {
                "condition": "if user clicks '停止'",
                "id": 5
              },
              {
                "condition": "if user clicks '记录'",
                "id": 6
              },
              {
                "condition": "if user clicks '查看'",
                "id": 7
              }
            ]
          },
          {
            "id": 3,
            "name": "设置提醒时间",
            "description": "用户设置喝水提醒的时间间隔",
            "input": "时间间隔（如30分钟）",
            "output": "定时提醒设置成功",
            "jump-list": [
              {
                "condition": "always",
                "id": 2
              }
            ]
          },
          {
            "id": 4,
            "name": "启动提醒",
            "description": "启动定时喝水提醒功能",
            "input": "无",
            "output": "提醒功能已启动",
            "jump-list": [
              {
                "condition": "always",
                "id": 2
              }
            ]
          },
          {
            "id": 5,
            "name": "停止提醒",
            "description": "停止定时喝水提醒功能",
            "input": "无",
            "output": "提醒功能已停止",
            "jump-list": [
              {
                "condition": "always",
                "id": 2
              }
            ]
          },
          {
            "id": 6,
            "name": "记录喝水",
            "description": "用户记录每次喝水的情况",
            "input": "喝水时间、水量",
            "output": "喝水记录保存成功",
            "jump-list": [
              {
                "condition": "always",
                "id": 2
              }
            ]
          },
          {
            "id": 7,
            "name": "查看记录",
            "description": "用户查看历史喝水记录",
            "input": "无",
            "output": "历史喝水记录列表",
            "jump-list": [
              {
                "condition": "always",
                "id": 2
              }
            ]
          }
        ],
        "language": "web应用（如vue、React）"
      },
      "workflowID": 21
    },
    "message": "成功生成工作流",
    "status": "success"
  }


  return mockdata
}

/**
 * Mock代码数据，用于开发阶段测试
 * @param {Object} workflow - 工作流结构
 * @returns {string} - 模拟的代码
 */
function mockCode(workflow) {
  let mockdata = {
    "data": {
      "fileNo": "186312888",
      "pathList": [
        "README.md",
        "public",
        "public\\index.html",
        "src",
        "src\\App.css",
        "src\\App.tsx",
        "src\\index.tsx"
      ]
    },
    "message": "项目代码生成成功",
    "status": "success"
  }
  return mockdata
}

/**
 * Mock部署指南数据，用于开发阶段测试
 * @param {Object} workflow - 工作流结构
 * @returns {string} - 模拟的部署指南
 */
function mockDeployGuide(workflow) {
  return "# 定时喝水提醒应用\n\n## 项目简介\n这是一个简单的定时喝水提醒Web应用，可以帮助用户设置喝水提醒时间间隔，记录喝水情况并查看历史记录。\n\n## 技术栈\n- React\n- TypeScript\n- LocalStorage (用于数据持久化)\n\n## 依赖安装\n```bash\nnpm install\n```\n\n## 运行命令\n```bash\nnpm start\n```\n\n## 本地测试\n应用启动后会自动打开浏览器访问 http://localhost:3000\n\n"

}
function mockSingleFile(fileNo, path) {
  return "# 简易聊天室应aaaaaaaaaaaaaaaaaaaa啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊用## 项目简介这是一个基于React和Node.js的简易聊天室应用，包含用户注册、登录、聊天室选择、消息收发和在线用户查看等功能## 技术栈- 前端: React.js- 后端: Node.js + Express- 数据库: 内存存储(开发环境)## 依赖安装### 后端```bash";
}